home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / pluginy Firefox / 684 / 684.xpi / chrome / fireftp.jar / content / js / remote / remoteDirTree.js next >
Encoding:
Text File  |  2008-06-14  |  23.2 KB  |  605 lines
  1. var remoteDirTree = {
  2.   data          : new Array(),
  3.   rowCount      : 0,
  4.   extraCallback : null,
  5.   dirtyList     : new Array(),
  6.   ignoreSelect  : false,
  7.  
  8.   getCellText         : function(row, column)       { return this.data[row].leafName; },
  9.   getLevel            : function(row)               { return this.data[row].level; },
  10.   getParentIndex      : function(row)               { return this.data[row].parentIndex; },
  11.   getImageSrc         : function(row, col)          { },
  12.   getColumnProperties : function(colid, col, props) { },
  13.   getRowProperties    : function(row, props)        { },
  14.   hasNextSibling      : function(row, nextrow)      { return this.data[row].hasNext; },
  15.   isContainer         : function(row)               { return true; },
  16.   isContainerEmpty    : function(row)               { return this.data[row].empty; },
  17.   isContainerOpen     : function(row)               { return this.data[row].open; },
  18.   isSeparator         : function(row)               { return false; },
  19.   isSorted            : function(row)               { return false; },
  20.   setTree             : function(treebox)           { this.treebox = treebox; },
  21.  
  22.   getCellProperties : function(row, col, props)   {
  23.     if (row >= 0 && row < this.data.length && this.data[row]) {
  24.       if (!gFtp.isConnected) {
  25.         props.AppendElement(gAtomService.getAtom("disconnected"));
  26.       }
  27.  
  28.       if (this.data[row].isHidden) {
  29.         props.AppendElement(gAtomService.getAtom("hidden"));
  30.       }
  31.     }
  32.   },
  33.  
  34.   toggleOpenState     : function(row, suppressChange) {
  35.     if (!gFtp.isConnected || gFtp.isListing()) {
  36.       return;
  37.     }
  38.  
  39.     if (this.isContainerOpen(row)) {
  40.       var level     = this.data[row].level;
  41.       var lastChild = row;
  42.  
  43.       while (lastChild + 1 < this.rowCount && this.data[lastChild + 1].level > level) {            // find last index in same level as collapsed dir
  44.         ++lastChild;
  45.       }
  46.  
  47.       this.data[row].children = this.data.splice(row + 1, lastChild - row);                        // get rid of subdirectories from view
  48.       this.updateParentIndices();
  49.       this.rowCount = this.data.length;
  50.       this.treebox.rowCountChanged(row, -(lastChild - row));
  51.  
  52.       this.data[row].open = false;
  53.       this.treebox.invalidateRow(row);                                                             // update row
  54.  
  55.       var remotePathSlash = gRemotePath.value   + (gRemotePath.value.charAt(gRemotePath.value.length - 1)     != "/" ? "/" : '');
  56.       var dataPathSlash   = this.data[row].path + (this.data[row].path.charAt(this.data[row].path.length - 1) != "/" ? "/" : '');
  57.  
  58.       if (remotePathSlash.indexOf(dataPathSlash) == 0 && gRemotePath.value != this.data[row].path
  59.        && gRemotePath.value.match(/\x2f/g).length > this.data[row].level && !suppressChange) {
  60.         gRemotePath.value = this.data[row].path;                                                   // we were in a subdirectory and we collapsed
  61.         this.selection.select(row);
  62.         this.treebox.ensureRowIsVisible(row);
  63.         remoteTree.updateView();
  64.       } else if (gRemotePath.value == this.data[row].path) {
  65.         this.selection.select(row);
  66.         this.treebox.ensureRowIsVisible(row);
  67.       }
  68.  
  69.       this.horizontalScroll(false, row);
  70.     } else {
  71.       for (var x = 0; x < this.dirtyList.length; ++x) {                                            // see if the row is dirty
  72.         if (this.dirtyList[x] == this.data[row].path) {
  73.           this.dirtyList.splice(x, 1);
  74.           this.data[row].children = null;
  75.           break;
  76.         }
  77.       }
  78.  
  79.       if (this.data[row].children) {                                                               // see if any of the rows children are dirty
  80.         for (var x = 0; x < this.dirtyList.length; ++x) {
  81.           var found = false;
  82.  
  83.           for (var y = this.data[row].children.length - 1; y >= 0; --y) {
  84.             if (this.data[row].children[y].path == this.dirtyList[x]) {
  85.               found = true;
  86.               this.data[row].children[y].children = null;
  87.               this.data[row].children[y].open     = false;
  88.               this.data[row].children[y].empty    = false;
  89.             } else if (this.data[row].children[y].path.indexOf(this.dirtyList[x]
  90.                                                             + (this.dirtyList[x].charAt(this.dirtyList[x].length - 1) != "/" ? "/" : '')) == 0) {
  91.               found = true;
  92.               this.data[row].children.splice(y, 1);
  93.             }
  94.           }
  95.  
  96.           if (found) {
  97.             this.dirtyList.splice(x, 1);
  98.           }
  99.         }
  100.       }
  101.  
  102.       if (this.data[row].children) {                                                               // stored from before
  103.         for (var x = this.data[row].children.length - 1; x >= 0; --x) {
  104.           this.data.splice(row + 1, 0, this.data[row].children[x]);
  105.         }
  106.  
  107.         this.updateParentIndices();
  108.         this.rowCount           = this.data.length;
  109.         this.treebox.rowCountChanged(row + 1, this.data[row].children.length);
  110.         this.data[row].children = null;
  111.         this.data[row].open     = true;
  112.         this.treebox.invalidateRow(row);
  113.  
  114.         this.horizontalScroll(true, row);
  115.       } else {
  116.         gFtp.list(this.data[row].path, "remoteDirTree.toggleOpenState2(" + row + ")", false);      // get data for this directory
  117.       }
  118.     }
  119.   },
  120.  
  121.   toggleOpenState2 : function(row) {
  122.     var newDirectories = new Array();
  123.  
  124.     for (var x = 0; x < gFtp.listData.length; ++x) {                                               // pick out the directories
  125.       if (gFtp.listData[x].isDirectory()) {
  126.         newDirectories.push(gFtp.listData[x]);
  127.       }
  128.     }
  129.  
  130.     if (newDirectories.length == 0)  {                                                             // no subdirectories
  131.       this.data[row].empty = true;
  132.       this.data[row].open  = false;
  133.     } else {                                                                                       // has subdirectories
  134.       for (var x = 0; x < newDirectories.length; ++x) {
  135.         var path          = gFtp.constructPath(this.data[row].path, newDirectories[x].leafName);
  136.         var parentDir     = this.data[row].path;
  137.         newDirectories[x] = { open        : false,
  138.                               empty       : false,
  139.                               hasNext     : true,
  140.                               parentIndex : -1,
  141.                               children    : null,
  142.                               path        : path,
  143.                               leafName    : newDirectories[x].leafName,
  144.                               parent      : parentDir,
  145.                               level       : path.match(/\x2f/g).length,
  146.                               sortPath    : path.replace(/\x2f/g, "\x01").toLowerCase(),
  147.                               isHidden    : newDirectories[x].isHidden };
  148.       }
  149.  
  150.       newDirectories.sort(directorySort);
  151.       newDirectories[newDirectories.length - 1].hasNext = false;                                   // last one doesn't have a next
  152.  
  153.       for (var x = newDirectories.length - 1; x >= 0; --x) {
  154.         this.data.splice(row + 1, 0, newDirectories[x]);
  155.       }
  156.  
  157.       this.updateParentIndices();
  158.       this.rowCount       = this.data.length;
  159.       this.treebox.rowCountChanged(row + 1, newDirectories.length);
  160.       this.data[row].open = true;
  161.     }
  162.  
  163.     this.treebox.invalidateRow(row);
  164.  
  165.     this.horizontalScroll(true, row);
  166.  
  167.     if (this.updateViewAfter) {
  168.       this.updateViewAfter = false;
  169.       remoteTree.updateView2();
  170.     }
  171.  
  172.     if (this.extraCallback) {
  173.       var tempCallback   = this.extraCallback;
  174.       this.extraCallback = null;
  175.       tempCallback();
  176.     }
  177.   },
  178.  
  179.   horizontalScroll : function(doOpen, row) {                                                       // horizontal scrollbars, baby!
  180.     $('remotedirname').removeAttribute('flex');
  181.  
  182.     var max = 125;
  183.     for (var z = 0; z < this.rowCount; ++z) {                                                      // this is what we CS folk like to call a TOTAL HACK
  184.       var x = { };    var y = { };    var width = { };    var height = { };                        // but, hey, it works so bite me
  185.       this.treebox.getCoordsForCellItem(z, this.treebox.columns["remotedirname"], "text", x, y, width, height);
  186.  
  187.       if (x.value + width.value + 125 > max) {
  188.         max = x.value + width.value + 125;
  189.       }
  190.     }
  191.  
  192.     //if (doOpen) {
  193.       this.readjustHorizontalPosition(row);
  194.     //}
  195.  
  196.     $('remotedirname').setAttribute('width', max);
  197.   },
  198.  
  199.   readjustHorizontalPosition : function(row) {
  200.     var x = { };    var y = { };    var width = { };    var height = { };
  201.     var first = this.treebox.getFirstVisibleRow()    > 0  ? this.treebox.getFirstVisibleRow()    : 0;
  202.     var last  = this.treebox.getLastVisibleRow() - 1 >= 0 ? this.treebox.getLastVisibleRow() - 1 : 0;
  203.  
  204.     this.treebox.getCoordsForCellItem(row != -1 ? row : 0, this.treebox.columns["remotedirname"], "text", x, y, width, height);
  205.     this.treebox.scrollToHorizontalPosition(this.treebox.horizontalPosition + x.value - 60 >= 0 ? this.treebox.horizontalPosition + x.value - 60 : 0);
  206.  
  207.     var self = this;
  208.     var func = function() {
  209.       self.treebox.ensureRowIsVisible(last);
  210.       self.treebox.ensureRowIsVisible(first);
  211.     };
  212.     if (first < this.data.length) {
  213.       setTimeout(func, 0);
  214.     }
  215.   },
  216.  
  217.   addDirtyList : function(path) {
  218.     gFtp.removeCacheEntry(path);
  219.  
  220.     for (var x = 0; x < this.dirtyList.length; ++x) {
  221.       if (this.dirtyList[x] == path) {
  222.         return;
  223.       }
  224.     }
  225.  
  226.     this.dirtyList.push(path);
  227.   },
  228.  
  229.   updateParentIndices : function() {
  230.     for (var x = 0; x < this.data.length; ++x) {
  231.       this.data[x].parentIndex = this.indexOfPath(this.data[x].parent);                            // ah, beautiful
  232.     }
  233.   },
  234.  
  235.   indexOfPath : function(path) {                                                                   // binary search to find a path in the remoteDirTree
  236.     if (!path) {
  237.       return -1;
  238.     }
  239.  
  240.     var left      = 0;
  241.     var right     = this.data.length - 1;
  242.     var origPath  = path;
  243.     path          = path.replace(/\x2f/g, "\x01").toLowerCase();
  244.  
  245.     while (left <= right) {
  246.       var mid      = Math.floor((left + right) / 2);
  247.       var dataPath = this.data[mid].sortPath;
  248.       if (this.data[mid].path == origPath || this.data[mid].path + "/" == origPath || this.data[mid].path == origPath + "/") {
  249.         return mid;
  250.       } else if (dataPath == path || dataPath + "\x01" == path || dataPath == path + "\x01") {
  251.         break;
  252.       } else if (path < dataPath) {
  253.         right = mid - 1;
  254.       } else if (path > dataPath) {
  255.         left  = mid + 1;
  256.       }
  257.     }
  258.  
  259.     for (var x = 0; x < this.data.length; ++x) {                                                   // last ditch effort b/c of we have to account for case
  260.       if (this.data[x].path == origPath || this.data[x].path + "/" == origPath || this.data[x].path == origPath + "/") {
  261.         return x;
  262.       }
  263.     }
  264.  
  265.     return -1;
  266.   },
  267.  
  268.   cdup : function() {
  269.     var parentIndex = this.getParentIndex(this.selection.currentIndex);
  270.  
  271.     if (parentIndex != -1) {
  272.       this.selection.select(parentIndex);
  273.     }
  274.   },
  275.  
  276.   updateViewAfter : false,
  277.  
  278.   changeDir : function(path) {
  279.     if (!gFtp.isConnected || gFtp.isListing()) {
  280.       if (!gFtp.isConnected) {
  281.         gTreeSyncManager = null;
  282.       }
  283.  
  284.       return;
  285.     }
  286.  
  287.     gRemotePath.value = path;
  288.  
  289.     if (this.data.length == 0) {                                                                   // if dirTree is empty
  290.       var oldRowCount = this.rowCount;
  291.       this.data       = new Array();
  292.       this.rowCount   = 0;
  293.       this.treebox.rowCountChanged(0, -oldRowCount);
  294.  
  295.       this.data.push({ open        : false,                                                        // restart the tree
  296.                        empty       : false,
  297.                        hasNext     : false,
  298.                        parentIndex : -1,
  299.                        children    : null,
  300.                        path        : "/",
  301.                        leafName    : "/",
  302.                        parent      : "",
  303.                        level       : 0,
  304.                        sortPath    : "/".replace(/\x2f/g, "\x01").toLowerCase() });
  305.  
  306.       this.rowCount = 1;
  307.       this.treebox.rowCountChanged(0, 1);
  308.     }
  309.                                                                                                    // error checking here for correct values in path
  310.     gRemotePath.value = gRemotePath.value.replace(/\x5c/g, "/");                                   // shouldn't have backslashes
  311.  
  312.     if (gRemotePath.value != '/' && gRemotePath.value.charAt(gRemotePath.value.length - 1) == '/') {
  313.       gRemotePath.value = gRemotePath.value.substring(0, gRemotePath.value.length - 1);            // cannot end with '\' ruins levels in dir tree
  314.     }
  315.  
  316.     if (gRemotePath.value.charAt(0) != '/') {                                                      // has to start with '/'
  317.       gRemotePath.value = '/' + gRemotePath.value;
  318.     }
  319.  
  320.     for (var x = 0; x < this.data.length; ++x) {                                                   // open parent directories til we find the directory
  321.       for (var y = this.data.length - 1; y >= x; --y) {
  322.         if (gRemotePath.value.indexOf(this.data[y].path) == 0) {
  323.           x = y;
  324.           break;
  325.         }
  326.       }
  327.  
  328.       if (gRemotePath.value.indexOf(this.data[x].path) == 0) {
  329.         var dirty = false;
  330.  
  331.         for (var z = 0; z < this.dirtyList.length; ++z) {
  332.           if (this.dirtyList[z] == this.data[x].path) {
  333.             dirty = true;
  334.             break;
  335.           }
  336.         }
  337.  
  338.         if (this.data[x].open && dirty) {
  339.           this.ignoreSelect = true;
  340.           this.toggleOpenState(x);
  341.           this.ignoreSelect = false;
  342.         }
  343.  
  344.         if (this.data[x].empty && dirty) {
  345.           this.data[x].empty = false;
  346.           this.treebox.invalidateRow(x);
  347.         }
  348.  
  349.         if (!this.data[x].open && !this.data[x].empty && gRemotePath.value != this.data[x].path) {
  350.           gRemotePath.value = this.data[x].path;
  351.           gRemotePathFocus  = this.data[x].path;
  352.           this.selection.select(x);
  353.           gFtp.list(this.data[x].path, "remoteDirTree.toggleOpenState2(" + x + ");remoteDirTree.changeDir('" + path.replace(/'/g, "\\'") + "')", false);
  354.           return;
  355.         } else if (gRemotePath.value == this.data[x].path) {
  356.           gRemotePathFocus = gRemotePath.value;                                                    // directory approved
  357.           gFormHistory.addEntry(gRemotePath.getAttribute("autocompletesearchparam"), gRemotePath.value);
  358.  
  359.           if (!this.data[x].open && !this.data[x].empty && x == 0) {
  360.             this.updateViewAfter = true;
  361.             this.toggleOpenState(x);
  362.           } else {
  363.             remoteTree.updateView();
  364.  
  365.             this.readjustHorizontalPosition(this.selection.currentIndex);
  366.           }
  367.  
  368.           if (gTreeSync && !gTreeSyncManager) {
  369.             treeSyncManager(false);
  370.           } else {
  371.             gTreeSyncManager = false;
  372.           }
  373.  
  374.           return;
  375.         }
  376.       }
  377.     }
  378.  
  379.     if (gTreeSyncManager) {
  380.       gTreeSyncManager  = false;
  381.       gRemotePath.value = gRemotePathFocus;
  382.       remoteTree.updateView();
  383.       return;
  384.     }
  385.  
  386.     this.dontPanic();
  387.   },
  388.  
  389.   dontPanic : function() {                                                                         // we haven't found the directory in the conventional
  390.     gRemotePathFocus = gRemotePath.value;                                                          // sense: don't freak out, just create directories
  391.     this.treebox.rowCountChanged(0, -this.rowCount);                                               // above as if it were there and list
  392.     this.rowCount    = 0;
  393.     this.data        = new Array();
  394.     this.data.push({ open        : true,                                                           // restart the tree
  395.                      empty       : false,
  396.                      hasNext     : false,
  397.                      parentIndex : -1,
  398.                      children    : null,
  399.                      path        : "/",
  400.                      leafName    : "/",
  401.                      parent      : "",
  402.                      level       : 0,
  403.                      sortPath    : "/".replace(/\x2f/g, "\x01").toLowerCase() });
  404.  
  405.     var paths     = gRemotePath.value.split("/");
  406.     var parentDir = "/";
  407.  
  408.     for (var x = 0; x < paths.length; ++x) {
  409.       if (paths[x] != "") {
  410.         var path = gFtp.constructPath(parentDir, paths[x]);
  411.         this.data.push({ open        : true,
  412.                          empty       : false,
  413.                          hasNext     : false,
  414.                          parentIndex : -1,
  415.                          children    : null,
  416.                          path        : path,
  417.                          leafName    : paths[x],
  418.                          parent      : parentDir,
  419.                          level       : path.match(/\x2f/g).length,
  420.                          sortPath    : path.replace(/\x2f/g, "\x01").toLowerCase() });
  421.  
  422.         parentDir += (parentDir != "/" ? "/" : "") + paths[x];
  423.       }
  424.     }
  425.  
  426.     this.data[this.data.length - 1].open = false;                                                  // make last directory closed
  427.  
  428.     this.updateParentIndices();
  429.     this.rowCount = this.data.length;                                                              // update tree
  430.     this.treebox.rowCountChanged(0, this.rowCount);
  431.     this.selection.select(this.rowCount - 1);
  432.  
  433.     this.updateViewAfter = true;                                                                   // open up the last directory
  434.     this.toggleOpenState(this.data.length - 1);
  435.   },
  436.  
  437.   select : function(event) {
  438.     if (this.ignoreSelect) {
  439.       return;
  440.     }
  441.  
  442.     var index = this.selection.currentIndex;
  443.  
  444.     if (index >= 0 && index < this.data.length && this.data[index].path != gRemotePath.value) {
  445.       this.changeDir(this.data[index].path);
  446.     }
  447.   },
  448.  
  449.   click : function(event) {                                                                        // this is a special case: if we want the search to go away
  450.     var index = this.selection.currentIndex;
  451.  
  452.     if (index >= 0 && index < this.data.length && (this.data[index].path == gRemotePath.value && remoteTree.searchMode)) {
  453.       this.changeDir(this.data[index].path);
  454.     }
  455.   },
  456.  
  457.   keyPress : function(event) {
  458.     if (event.keyCode == 8) {                                                                      // backspace
  459.       this.cdup();
  460.     } else if (event.keyCode == 116) {                                                             // F5
  461.       event.preventDefault();
  462.       remoteTree.refresh();
  463.     }
  464.   },
  465.  
  466.   canDrop : function(index, orient) {
  467.     if (!gFtp.isConnected || index == -1 || orient != 0 || !dragObserver.origin) {
  468.       return false;
  469.     }
  470.  
  471.     if (dragObserver.origin == 'remotetreechildren') {                                             // can't move into a subdirectory of itself
  472.       for (var x = 0; x < remoteTree.rowCount; ++x) {
  473.         var remotePath      = remoteTree.data[x].path;
  474.         var dataPathSlash   = this.data[index].path + (this.data[index].path.charAt(this.data[index].path.length - 1) != "/" ? "/" : '');
  475.         var remotePathSlash = remotePath            + (remotePath.charAt(remotePath.length - 1)                       != "/" ? "/" : '');
  476.  
  477.         if (remoteTree.selection.isSelected(x) && ((dataPathSlash.indexOf(remotePathSlash) == 0 && remoteTree.data[x].isDirectory())
  478.                                                  || this.data[index].path ==
  479.                                                     remotePath.substring(0, remotePath.lastIndexOf('/') ? remotePath.lastIndexOf('/') : 1))) {
  480.           return false;
  481.         }
  482.       }
  483.     }
  484.  
  485.     return true;
  486.   },
  487.  
  488.   drop : function(index, orient) {
  489.     if (dragObserver.origin == 'remotetreechildren') {
  490.       remoteTree.cut();
  491.  
  492.       var self = this;
  493.       var path = this.data[index].path;
  494.       var func = function() { remoteTree.paste(path); };
  495.       gFtp.list(this.data[index].path, func, true);
  496.     } else if (dragObserver.origin == 'localtreechildren') {
  497.       var anyFolders = false;
  498.  
  499.       for (var x = 0; x < localTree.rowCount; ++x) {
  500.         if (localTree.selection.isSelected(x) && localTree.data[x].isDirectory()) {
  501.           anyFolders = true;
  502.           break;
  503.         }
  504.       }
  505.  
  506.       var path = this.data[index].path;
  507.  
  508.       if (anyFolders && this.data[index].path != gRemotePath.value) {
  509.         var self       = this;
  510.         var remotePath = gRemotePath.value;
  511.         var func = function() { self.dropCallback(path, remotePath); };
  512.         ftpObserver.extraCallback = func;
  513.       }
  514.  
  515.       var self                  = this;
  516.       var transferObj           = new transfer();
  517.       transferObj.remoteRefresh = gRemotePath.value;
  518.       var func = function() { transferObj.start(false, '', '', path); };
  519.       gFtp.list(this.data[index].path, func, true);
  520.     } else if (dragObserver.origin == 'external') {
  521.       var anyFolders = false;
  522.  
  523.       for (var x = 0; x < dragObserver.externalFiles.length; ++x) {
  524.         if (dragObserver.externalFiles[x].isDirectory()) {
  525.           anyFolders = true;
  526.           break;
  527.         }
  528.       }
  529.  
  530.       if (anyFolders && this.data[index].path != gRemotePath.value) {
  531.         var self       = this;
  532.         var path       = this.data[index].path;
  533.         var remotePath = gRemotePath.value;
  534.         var func       = function() { self.dropCallback(path, remotePath); };
  535.         ftpObserver.extraCallback = func;
  536.       }
  537.  
  538.       var transferObj           = new transfer();
  539.       transferObj.remoteRefresh = gRemotePath.value;
  540.  
  541.       for (var x = 0; x < dragObserver.externalFiles.length; ++x) {
  542.         var droppedFile = dragObserver.externalFiles[x];
  543.         var fileParent  = droppedFile.parent ? droppedFile.parent.path : "";
  544.  
  545.         this.dropHelper(transferObj, droppedFile, fileParent, index);
  546.  
  547.         if (transferObj.cancel) {
  548.           break;
  549.         }
  550.       }
  551.     }
  552.   },
  553.  
  554.   dropHelper : function(transferObj, droppedFile, fileParent, index) {
  555.     var self                  = this;
  556.     var remotePath            = this.data[index].path;
  557.     var func                  = function() { transferObj.start(false, droppedFile, fileParent, remotePath); };
  558.     gFtp.list(this.data[index].path, func, true);
  559.   },
  560.  
  561.   dropCallback : function(newParent, remotePath) {
  562.     var refreshIndex = this.indexOfPath(newParent);
  563.  
  564.     if (refreshIndex != -1) {
  565.       if (this.data[refreshIndex].open) {
  566.         var self           = this;
  567.         var path           = remotePath;
  568.         var dropCallback2  = function() { self.dropCallback2(path); };
  569.         this.extraCallback = dropCallback2;
  570.  
  571.         this.toggleOpenState(refreshIndex, true);                                                  // close it up
  572.         this.data[refreshIndex].children = null;                                                   // reset its children
  573.         this.toggleOpenState(refreshIndex);                                                        // and open it up again
  574.         return;
  575.       } else {
  576.         this.data[refreshIndex].children = null;                                                   // reset its children
  577.         this.data[refreshIndex].empty    = false;
  578.         this.treebox.invalidateRow(refreshIndex);
  579.       }
  580.  
  581.       var refreshIndex2 = this.indexOfPath(remotePath);
  582.  
  583.       if (refreshIndex2 == -1) {
  584.         this.changeDir(remotePath);
  585.         return;
  586.       } else {
  587.         this.selection.select(refreshIndex2);
  588.       }
  589.     } else {
  590.       this.addDirtyList(newParent);
  591.     }
  592.   },
  593.  
  594.   dropCallback2 : function(returnDir) {
  595.     var refreshIndex2 = this.indexOfPath(returnDir);
  596.  
  597.     if (refreshIndex2 == -1) {
  598.       this.changeDir(returnDir);
  599.       return;
  600.     } else {
  601.       this.selection.select(refreshIndex2);
  602.     }
  603.   }
  604. };
  605.